package com.black.cat.bean;

import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;

public class SimpleAliasRegistry implements AliasRegistry {

    //  key:alias, value:name
    private final Map<String, String> aliasMap = new ConcurrentHashMap<>(16);


    @Override
    public void registerAlias(String name, String alias) {
        //参数校验
 //       Assert.hasText(name, "'name' must not be empty");
 //       Assert.hasText(alias, "'alias' must not be empty");
        //加锁    map 的复合操作线程安全
        synchronized (this.aliasMap) {
            if (alias.equals(name)) {
                //如果别名和名称相同，则移除这个别名
                this.aliasMap.remove(alias);
            }else{
                //获取当前别名在注册表中的规范名称
                String registeredName = this.aliasMap.get(alias);
                if(registeredName != null){
                    //规范名称存在，不需要注册，返回
                    if (registeredName.equals(name)) {
                        return;
                    }
                    //判断是否允许重写注册   默认true 允许重写
                    if (!allowAliasOverriding()) {
                        throw new IllegalStateException("");
                    }
                }
                // 校验规范名称是否指向当前别名的    a->b   b->c   c->a 这就循环引用
                // 如果循环引用不限制,在获取A的别名的一直在那边循环(递归没有出口)
                checkForAliasCircle(name, alias);
                // 注册表注册别名与规范名称的映射
                this.aliasMap.put(alias, name);
            }
        }
    }

    protected boolean allowAliasOverriding() {
        return true;
    }

    protected void checkForAliasCircle(String name, String alias) {
        if (hasAlias(alias, name)) {
            throw new IllegalStateException("Cannot register alias '" + alias +
                    "' for name '" + name + "': Circular reference - '" +
                    name + "' is a direct or indirect alias for '" + alias + "' already");
        }
    }


    public boolean hasAlias(String name, String alias) {
        //遍历注册表
        for (Map.Entry<String, String> entry : this.aliasMap.entrySet()) {
            //注册表中单映射的规范名称name
            String registeredName = entry.getValue();
            //判断name是否与传入name一致
            if (registeredName.equals(name)) {
                //获取注册表单项的别名
                String registeredAlias = entry.getKey();

                // hasAlias(registeredAlias, alias)) 检测是否存在循环引用

                // 循环引用如下
                // 注册表: A-B; C-A;D-C
                // B对应的别名有ACD
                // A对应的别名别名CD
                // C对应的别名有D
                // 是循环引用 此处需要校验
                return (registeredAlias.equals(alias) || hasAlias(registeredAlias, alias));
            }
        }
        return false;
    }

    /**
     *
     *
     * 	 取指定的 alias 所表示的最终 beanName。
     * 	 主要是一个循环获取 beanName 的过程，例如别名A指向名称为B的bean则返回B，
     * 	 若别名A指向别名B，别名B 指向名称为C的 bean，则返回C。
     *
     * Determine the raw name, resolving aliases to canonical names.
     * @param name the user-specified name
     * @return the transformed name
     */
    public String canonicalName(String name) {
        String canonicalName = name;
        // Handle aliasing...
        String resolvedName;
        do {
            resolvedName = this.aliasMap.get(canonicalName);
            if (resolvedName != null) {
                canonicalName = resolvedName;
            }
        }
        while (resolvedName != null);
        return canonicalName;
    }
}
